// index.js
const defaultAvatarUrl = '/pages/img/head.jpg'
Page({
    data: {
        motto: '欢迎使用扫码入库功能!',
        userInfo: {
            avatarUrl: defaultAvatarUrl,
            nickName: '',
        },
        hasLogin:false,
        hasUserInfo: false,
        canIUseGetUserProfile: wx.canIUse('getUserProfile'),
        canIUseNicknameComp: wx.canIUse('input.type.nickname'),
    },
    onLoad(){
        let token = wx.getStorageSync('hasToken')
        if(token){
            this.setData({
                hasLogin:true
            })
        }
    },
    bindViewTap() {
        wx.navigateTo({
            url: '../logs/logs'
        })
    },
    onChooseAvatar(e) {
        const {
            avatarUrl
        } = e.detail
        const {
            nickName
        } = this.data.userInfo
        this.setData({
            "userInfo.avatarUrl": avatarUrl,
            hasUserInfo: nickName && avatarUrl && avatarUrl !== defaultAvatarUrl,
        })
    },
    onInputChange(e) {
        const nickName = e.detail.value
        const {
            avatarUrl
        } = this.data.userInfo
        this.setData({
            "userInfo.nickName": nickName,
            hasUserInfo: nickName && avatarUrl && avatarUrl !== defaultAvatarUrl,
        })
    },
    getUserProfile(e) {
        // 推荐使用wx.getUserProfile获取用户信息，开发者每次通过该接口获取用户个人信息均需用户确认，开发者妥善保管用户快速填写的头像昵称，避免重复弹窗
        wx.getUserProfile({
            desc: '展示用户信息', // 声明获取用户个人信息后的用途，后续会展示在弹窗中，请谨慎填写
            success: (res) => {
                console.log(res)
                this.setData({
                    userInfo: res.userInfo,
                    hasUserInfo: true
                })
            }
        })
    },
    /**
     * 打开相机功能。
     * 此方法用于触发相机打开操作，并在成功时打印日志信息。
     */
    openCamera() {
        console.log("success!")
        // 调用微信的扫码功能
        wx.scanCode({
            success: (res) => {
                let itemId = res.result.split("_")[0]
                let inputNum =  res.result.split("_")[1]
                wx.showToast({
                    title: '正在入库',
                    icon: 'loading', // 可以是'success'、'loading'、'none'
                    duration: 2000 // 提示显示的时间，单位是毫秒
                })
                // console.log(res.result); // 扫码结果
                // 这里可以添加处理扫码结果的逻辑

                // 将信息发送至后端
                let hasToken = wx.getStorageSync('hasToken')
                // console.log('本地token', hasToken)
                if (!hasToken) {
                    wx.showToast({
                        title: '未登录,请登录!',
                        icon: 'loading',
                        duration: 1000
                    })
                    setTimeout(() => {
                        wx.navigateTo({
                            url: '/pages/login/login'
                        });
                    }, 800);
                }
                this.queryItemInfo(itemId,inputNum,88,100)
            },
            fail: (err) => {
                console.error(err); // 扫码失败信息
            }
        })
    },

    /**
     * 判断是否登录
     */
    judgeIsLogin(){
        let hasToken = wx.getStorageSync('hasToken')
        if (!hasToken) {
            wx.showToast({
                title: '未登录,请登录!',
                icon: 'loading',
                duration: 1000
            })
            setTimeout(() => {
                wx.navigateTo({
                    url: '/pages/login/login'
                });
            }, 800);
        }
    },

    /**
     * 清除本地缓存
     */
    clearAll(){
        try {
            wx.clearStorageSync();
            console.log("本地缓存已成功清除");
        } catch (e) {
            console.error("清除本地缓存时出错：", e);
        }
    },
    /**
     * 查询商品库存，判断是否可入库
     */
    queryItemInfo(itemId,inputNum,warehouseId,inventoryPeople){
        let hasToken = wx.getStorageSync('hasToken')
        wx.request({
            url: `http://10.112.10.129:8080/system/info/${itemId}`, // 后端接口地址，替换为实际的URL
            method: 'GET', // 请求方法，也可以是 'GET'、'PUT'、'DELETE' 等，根据后端接口要求选择
            // data: {
            //     info: res.result,
            // }, // 要发送给后端的数据，格式通常为JSON对象，根据接口要求来组织数据结构
            header: {
                'content-type': 'application/json', // 头部设置，常用的还有 'application/x-www-form-urlencoded' 等，视情况而定
                'Authorization': 'Bearer ' + hasToken
            },
            // 注意注意！！！！'Bearer '+hasToken  Bearer后面有个空格
            success:(res)=> {
                console.log('物品出厂信息',res)
                let itemInfo = res.data.data
                let itemId = itemInfo.itemId
                let itemNum = itemInfo.itemNum
                let itemOtherInfo = itemInfo.itemOtherInfo
                if(itemNum<=inputNum){
                    wx.showToast({
                        title: '物品出厂库存不足,请联系厂家补库存!',
                        icon: 'none', // 可以是'success'、'loading'、'none'
                        duration: 5000 // 提示显示的时间，单位是毫秒
                    })
                    return
                }
                wx.showModal({
                    title: '物品信息确认',
                    content: itemOtherInfo+`\r\n入库数量：${inputNum}\r\n入库人(id)：${inventoryPeople}\r\n所入仓库(id):${warehouseId}`,
                    success: (res)=> {
                      if (res.confirm) {
                        // 更新出厂物品信息
                        let itemObj={
                            itemId:itemId,
                            // 减去入库数量
                            itemNum:itemNum - inputNum
                        }
                        try {
                            this.updateItemInfo(itemObj)
                        } catch (error) {
                            console.log(error);
                        }
                        
                        // 新增入库记录
                        let insertObj={
                            warehouseId:warehouseId,
                            // inventoryTime: 当前时间  后端自动生成
                            inventoryPeople:inventoryPeople,
                            inventoryNum:inputNum
                        }
                        try {
                            this.insertRecord(insertObj)
                        } catch (error) {
                            console.log(error);
                        }
                        
                        // 通过查询仓库出库是否存在记录  判断新增还是修改
                        try {
                            this.queryCurrentInventoryNum(warehouseId,itemId,inputNum)
                        } catch (error) {
                            console.log(error);
                        }
                        wx.showToast({
                          title: '入库成功',
                          icon:'success'
                        })
                        

                      } else if (res.cancel) {
                        console.log('用户取消了操作');
                      }
                    }
                  });
            },
            fail(err) {
                console.log(err)
                wx.showToast({
                    title: '物品信息查询失败',
                    icon: 'none', // 可以是'success'、'loading'、'none'
                    duration: 2000 // 提示显示的时间，单位是毫秒
                })
            }
        })
    },
    /**
     * 登录请求
     */
    sentRequest() {
        // console.log('模拟请求')
        // 检测本地token
        let hasToken = wx.getStorageSync('hasToken')
        // console.log('本地token', hasToken)
        if (!hasToken) {
            wx.showToast({
                title: '未登录,请登录!',
                icon: 'loading',
                duration: 1000
            })
            setTimeout(() => {
                wx.navigateTo({
                    url: '/pages/login/login'
                });
            }, 800);
        }
    },

    /**
     * 模拟已经获取到了物品id
     */
    sentItemId(){
        this.judgeIsLogin()
        // 条形码应该包含物品的id与这批货物的数量
        let itemId = 101
        let nums = 10;
        // 仓库id与入库人id，应该与扫码设备绑定
        let warehouseId = 88
        let inventoryPeople = 100
        this.queryItemInfo(itemId,nums,warehouseId,inventoryPeople)
    },

    /**
     * 更新出厂库存表(物品信息表)
     */
    updateItemInfo(updateObj){
        let hasToken = wx.getStorageSync('hasToken')
        wx.request({
            url: 'http://10.112.10.129:8080/system/info', // 后端接口地址，替换为实际的URL
            method: 'PUT', // 请求方法，也可以是 'GET'、'PUT'、'DELETE' 等，根据后端接口要求选择
            data:  updateObj,
            // 要发送给后端的数据，格式通常为JSON对象，根据接口要求来组织数据结构
            header: {
                'content-type': 'application/json', // 头部设置，常用的还有 'application/x-www-form-urlencoded' 等，视情况而定
                'Authorization': 'Bearer ' + hasToken
            },
            // 注意注意！！！！'Bearer '+hasToken  Bearer后面有个空格
            success(res) {
                console.log(res)
            },
            fail(err) {
                console.log(err)
                wx.showToast({
                    title: '更新失败',
                    icon: 'none', // 可以是'success'、'loading'、'none'
                    duration: 2000 // 提示显示的时间，单位是毫秒
                })
            }
        })
    },
     /**
     * 更新仓库库存表
     */
    updateInventory(updateObj){
        let hasToken = wx.getStorageSync('hasToken')
        wx.request({
            url: 'http://10.112.10.129:8080/system/inventory', // 后端接口地址，替换为实际的URL
            method: 'PUT', // 请求方法，也可以是 'GET'、'PUT'、'DELETE' 等，根据后端接口要求选择
            data: updateObj, // 要发送给后端的数据，格式通常为JSON对象，根据接口要求来组织数据结构
            header: {
                'content-type': 'application/json', // 头部设置，常用的还有 'application/x-www-form-urlencoded' 等，视情况而定
                'Authorization': 'Bearer ' + hasToken
            },
            // 注意注意！！！！'Bearer '+hasToken  Bearer后面有个空格
            success(res) {
                console.log(res)
            },
            fail(err) {
                console.log(err)
                wx.showToast({
                    title: '更新失败',
                    icon: 'none', // 可以是'success'、'loading'、'none'
                    duration: 2000 // 提示显示的时间，单位是毫秒
                })
            }
        })
    },

    /**
     * 新增仓库库存表
     */
    insertInventory(insertObj){
        let hasToken = wx.getStorageSync('hasToken')
        wx.request({
            url: 'http://10.112.10.129:8080/system/inventory', // 后端接口地址，替换为实际的URL
            method: 'POST', // 请求方法，也可以是 'GET'、'PUT'、'DELETE' 等，根据后端接口要求选择
            data: insertObj,
            // 要发送给后端的数据，格式通常为JSON对象，根据接口要求来组织数据结构
            header: {
                'content-type': 'application/json', // 头部设置，常用的还有 'application/x-www-form-urlencoded' 等，视情况而定
                'Authorization': 'Bearer ' + hasToken
            },
            // 注意注意！！！！'Bearer '+hasToken  Bearer后面有个空格
            success(res) {
                console.log(res)
            },
            fail(err) {
                console.log(err)
                wx.showToast({
                    title: '更新失败',
                    icon: 'none', // 可以是'success'、'loading'、'none'
                    duration: 2000 // 提示显示的时间，单位是毫秒
                })
            }
        })
    },
     /**
     * 新增入库记录表
     */
    insertRecord(insertObj){
        let hasToken = wx.getStorageSync('hasToken')
        wx.request({
            url: 'http://10.112.10.129:8080/system/record', // 后端接口地址，替换为实际的URL
            method: 'POST', // 请求方法，也可以是 'GET'、'PUT'、'DELETE' 等，根据后端接口要求选择
            data:insertObj, // 要发送给后端的数据，格式通常为JSON对象，根据接口要求来组织数据结构
            header: {
                'content-type': 'application/json', // 头部设置，常用的还有 'application/x-www-form-urlencoded' 等，视情况而定
                'Authorization': 'Bearer ' + hasToken
            },
            // 注意注意！！！！'Bearer '+hasToken  Bearer后面有个空格
            success(res) {
                console.log(res)
            },
            fail(err) {
                console.log(err)
                wx.showToast({
                    title: '更新失败',
                    icon: 'none', // 可以是'success'、'loading'、'none'
                    duration: 2000 // 提示显示的时间，单位是毫秒
                })
            }
        })
    },

    queryCurrentInventoryNum(warehouseId,itemId,inputNum){
        let hasToken = wx.getStorageSync('hasToken')
        wx.request({
            url: `http://10.112.10.129:8080/system/inventory/getInventoryByWarehouseIdAndItemId`, // 后端接口地址，替换为实际的URL
            method: 'POST', // 请求方法，也可以是 'GET'、'PUT'、'DELETE' 等，根据后端接口要求选择
            data: {
                warehouseId: warehouseId,
                itemId:itemId
            }, // 要发送给后端的数据，格式通常为JSON对象，根据接口要求来组织数据结构
            header: {
                'content-type': 'application/json', // 头部设置，常用的还有 'application/x-www-form-urlencoded' 等，视情况而定
                'Authorization': 'Bearer ' + hasToken
            },
            // 注意注意！！！！'Bearer '+hasToken  Bearer后面有个空格
            success:(res)=> {
                console.log('仓库库存信息',res)
                if(res.data===""){
                    let insertInventoryObj={
                        warehouseId:warehouseId,
                        itemId:itemId,
                        inventoryCurrentNum:inputNum
                    }
                    this.insertInventory(insertInventoryObj)
                }else{
                    let inventoryCurrentNum = parseInt(res.data.data.inventoryCurrentNum)
                    // 更新仓库库存
                    let updateInventoryObj={
                        warehouseId:warehouseId,
                        itemId:itemId,
                        inventoryCurrentNum:inventoryCurrentNum+parseInt(inputNum)
                    }
                    this.updateInventory(updateInventoryObj)
                }
            },
            fail(err) {
                console.log(err)
                wx.showToast({
                    title: '物品信息查询失败',
                    icon: 'none', // 可以是'success'、'loading'、'none'
                    duration: 2000 // 提示显示的时间，单位是毫秒
                })
            }
        })
    },
    hasLogined(){
        this.judgeIsLogin()
        // wx.showToast({
        //   title: '您已登陆!',
        // })
    }
})